const MenuModel = require('../models/menu.model');
const logger = require('../utils/logger');
const Response = require('../utils/response');

class MenuController {
  // 创建菜单
  async createMenu(req, res) {
    try {
      const { parent_id, name, menu_type, path, component, icon, sort, status } = req.body;
      
      // 验证必填字段
      if (!name || menu_type === undefined) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：菜单名称和类型为必填项'
          })
        );
      }

      // 验证菜单类型
      if (![1, 2, 3, 4, 5].includes(Number(menu_type))) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：菜单类型无效，必须是1-5之间的整数'
          })
        );
      }

      // 验证路径和组件（对于非权限控制类型的菜单）
      if (menu_type !== 5 && (!path || !component)) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：非权限控制类型的菜单必须提供路径和组件'
          })
        );
      }

      // 构建菜单数据
      const menuData = {
        parent_id: parent_id || 0,
        name,
        menu_type: Number(menu_type),
        path: menu_type === 5 ? null : path,
        component: menu_type === 5 ? null : component,
        icon,
        sort: sort || 0,
        status: status === undefined ? 1 : Number(status)
      };

      // 验证菜单类型和父级关系
      const validation = await MenuModel.validateMenuTypeAndParent(menuData);
      if (!validation.valid) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: `参数错误：${validation.message}`
          })
        );
      }

      // 创建菜单
      const menuId = await MenuModel.create(menuData);
      
      // 获取创建后的菜单数据
      const menu = await MenuModel.findById(menuId);
      
      return res.status(201).json(
        Response.success({
          code: 201,
          message: '创建菜单成功',
          data: menu
        })
      );
    } catch (error) {
      logger.error('创建菜单失败:', error);
      return res.status(500).json(
        Response.error({
          message: '系统错误：' + error.message
        })
      );
    }
  }

  // 更新菜单
  async updateMenu(req, res) {
    try {
      const { id } = req.params;
      const { name, menu_type, path, component, icon, sort, status } = req.body;
      
      // 验证菜单ID
      if (!id || isNaN(id)) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：无效的菜单ID'
          })
        );
      }

      // 检查菜单是否存在
      const existingMenu = await MenuModel.findById(id);
      if (!existingMenu) {
        return res.status(404).json(
          Response.error({
            code: 404,
            message: '资源不存在：菜单不存在或已被删除'
          })
        );
      }

      // 验证菜单类型
      if (menu_type !== undefined && ![1, 2, 3, 4, 5].includes(Number(menu_type))) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：菜单类型无效，必须是1-5之间的整数'
          })
        );
      }

      // 验证路径和组件（对于非权限控制类型的菜单）
      if (menu_type !== undefined && menu_type !== 5 && (!path && !existingMenu.path || !component && !existingMenu.component)) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：非权限控制类型的菜单必须提供路径和组件'
          })
        );
      }

      // 构建更新数据
      const menuData = {};
      
      if (name !== undefined) menuData.name = name;
      if (menu_type !== undefined) menuData.menu_type = Number(menu_type);
      if (path !== undefined) menuData.path = path;
      if (component !== undefined) menuData.component = component;
      if (icon !== undefined) menuData.icon = icon;
      if (sort !== undefined) menuData.sort = Number(sort);
      if (status !== undefined) menuData.status = Number(status);

      // 更新菜单
      const updated = await MenuModel.update(id, menuData);
      
      if (!updated) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '操作失败：菜单更新失败或没有变更'
          })
        );
      }
      
      // 获取更新后的菜单数据
      const menu = await MenuModel.findById(id);
      
      return res.status(200).json(
        Response.success({
          message: '更新菜单成功',
          data: menu
        })
      );
    } catch (error) {
      logger.error('更新菜单失败:', error);
      return res.status(500).json(
        Response.error({
          message: '系统错误：' + error.message
        })
      );
    }
  }

  // 删除菜单
  async deleteMenu(req, res) {
    try {
      const { id } = req.params;
      
      // 验证菜单ID
      if (!id || isNaN(id)) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：无效的菜单ID'
          })
        );
      }

      // 检查菜单是否存在
      const existingMenu = await MenuModel.findById(id);
      if (!existingMenu) {
        return res.status(404).json(
          Response.error({
            code: 404,
            message: '资源不存在：菜单不存在或已被删除'
          })
        );
      }

      // 删除菜单（包括子菜单和关联记录）
      const deleted = await MenuModel.softDelete(id);
      
      if (!deleted) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '操作失败：菜单删除失败'
          })
        );
      }
      
      return res.status(200).json(
        Response.success({
          message: '删除菜单成功'
        })
      );
    } catch (error) {
      logger.error('删除菜单失败:', error);
      return res.status(500).json(
        Response.error({
          message: '系统错误：' + error.message
        })
      );
    }
  }

  // 获取菜单详情
  async getMenuById(req, res) {
    try {
      const { id } = req.params;
      
      // 验证菜单ID
      if (!id || isNaN(id)) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：无效的菜单ID'
          })
        );
      }

      // 获取菜单
      const menu = await MenuModel.findById(id);
      
      if (!menu) {
        return res.status(404).json(
          Response.error({
            code: 404,
            message: '资源不存在：菜单不存在或已被删除'
          })
        );
      }
      
      return res.status(200).json(
        Response.success({
          data: menu
        })
      );
    } catch (error) {
      logger.error('获取菜单详情失败:', error);
      return res.status(500).json(
        Response.error({
          message: '系统错误：' + error.message
        })
      );
    }
  }

  // 获取所有菜单
  async getAllMenus(req, res) {
    try {
      const menus = await MenuModel.findAll();
      
      return res.status(200).json(
        Response.success({
          data: menus
        })
      );
    } catch (error) {
      logger.error('获取所有菜单失败:', error);
      return res.status(500).json(
        Response.error({
          message: '系统错误：' + error.message
        })
      );
    }
  }

  // 获取菜单树
  async getMenuTree(req, res) {
    try {
      const menuTree = await MenuModel.getMenuTree();
      
      return res.status(200).json(
        Response.success({
          data: menuTree
        })
      );
    } catch (error) {
      logger.error('获取菜单树失败:', error);
      return res.status(500).json(
        Response.error({
          message: '系统错误：' + error.message
        })
      );
    }
  }

  // 获取用户菜单
  async getUserMenus(req, res) {
    try {
      // 从请求中获取用户角色ID
      const roleId = req.user.role_id;
      
      if (!roleId) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '参数错误：无法获取用户角色信息'
          })
        );
      }
      
      const userMenus = await MenuModel.getUserMenus(roleId);
      
      return res.status(200).json(
        Response.success({
          data: userMenus
        })
      );
    } catch (error) {
      logger.error('获取用户菜单失败:', error);
      return res.status(500).json(
        Response.error({
          message: '系统错误：' + error.message
        })
      );
    }
  }
}

module.exports = new MenuController(); 